package global

import (
	"encoding/json"
	"fmt"
	"math"
	"os"
	"path/filepath"
	"reflect"
	"regexp"
	"runtime"
	"strconv"
	"strings"
	"time"
)

func OsExist() {
	os.Exit(0)
}
func PrintCaller() (res string) {
	// 获取调用栈信息
	pc := make([]uintptr, 10)   // 10 是调用栈的深度
	n := runtime.Callers(2, pc) // 2 表示跳过当前函数和上一层函数

	// 获取调用者的函数信息
	if n > 0 {
		frames := runtime.CallersFrames(pc[:n])
		for {
			frame, more := frames.Next()
			if !more {
				break
			}
			res = fmt.Sprintf("Function: %s, File: %s, Line: %d ", frame.Function, frame.File, frame.Line)
		}
	}
	return
}

// IsEmptyStruct 判断结构体是否为空，为空则返回为false
func IsEmptyStruct(s interface{}) bool {
	if s == nil {
		return true
	}
	// 获取结构体的反射值
	structValue := reflect.ValueOf(s)
	if structValue.Kind() == reflect.Ptr {
		return structValue.IsNil()
	}
	// 遍历结构体的字段
	for i := 0; i < structValue.NumField(); i++ {
		fieldValue := structValue.Field(i)
		// 判断字段是否为其零值或空值
		if !fieldValue.IsZero() {
			return false
		}
	}
	return true
}

func StrToInt64(s any) (r int64, err error) {
	switch fmt.Sprintf("%v", reflect.TypeOf(s)) {
	case "string":
		if r, err = strconv.ParseInt(fmt.Sprintf("%v", s), 10, 64); err != nil {
			return
		}
	}
	return
}
func AnyToString(s any) (r string) {
	return fmt.Sprintf("%v", s)
}

/*
StructToMap   struct json ==>map[string]string

	===>input
	type Person struct {
		Name string `json:"name"`
		Age  int    `json:"age"`
	}
	p := Person{
		Name: "John Doe",
		Age:  30,
	}
	output <=====
	map[age:30 name:John Doe]
*/
func StructToMap(v any) map[string]string {
	//event := "[global StructToMap]"
	jsonBytes, err := json.Marshal(v)
	if err != nil {
		//Wlog.Error(fmt.Sprintf("(%d) [%s] struct strconv json fail. error info is {%v}", 1, event, err))
		return nil
	}

	// 将JSON字节切片解码为map[string]interface{}
	var data map[string]interface{}
	err = json.Unmarshal(jsonBytes, &data)
	if err != nil {
		//Wlog.Error(fmt.Sprintf("(%d) [%s] json strconv map[string]interface fail. error info is {%v}", 1, event, err))
		return nil
	}
	// 创建映射的键值对
	mappings := make(map[string]string)
	for key, value := range data {
		if strValue, ok := value.(string); ok {
			mappings[key] = strValue
		}
	}
	return mappings
}

/*
StructToMapAny   struct json ==>map[string]any

	===>input
	type Person struct {
		Name string `json:"name"`
		Age  int    `json:"age"`
	}
	p := Person{
		Name: "John Doe",
		Age:  30,
	}
	output <=====
	map[age:30 name:John Doe]
*/
func StructToMapAny(v any) (map[string]any, error) {
	// 获取 v 的反射值
	value := reflect.ValueOf(v)
	// 检查 v 是否为指针
	if value.Kind() == reflect.Ptr {
		value = value.Elem()
	}
	// 检查 v 是否为结构体
	if value.Kind() != reflect.Struct {
		return nil, fmt.Errorf("input must be a struct")
	}
	// 初始化一个空的 map
	m := make(map[string]interface{})
	// 遍历结构体的字段
	for i := 0; i < value.NumField(); i++ {
		field := value.Field(i)
		fieldName := value.Type().Field(i).Name
		tag := value.Type().Field(i).Tag.Get("json")
		if tag != "" {
			fieldName = tag
		}
		m[fieldName] = field.Interface()
	}
	return m, nil
}

/*
StructSubToMapAny   struct json ==>map[string]any

	===>input
	type Person1 struct {
		Name string `json:"name"`
		Age  int    `json:"age"`
	}
	type Person struct {
		Name string `json:"name"`
		Age  int    `json:"age"`
		person1  Person1 `json:"Person1"`
	}
	p := Person{
		Name: "John Doe",
		Age:  30,
		Person1 : {
			Name:"aa",
			Age:29,
		}
	}
	output <=====
	map[age:30 name:John Doe Person1:map[name:aa,age:29]]
*/
func StructSubToMapAny(v any) (map[string]any, error) {
	objType := reflect.TypeOf(v)
	objValue := reflect.ValueOf(v)
	if objType.Kind() == reflect.Ptr {
		objType = objType.Elem()
		objValue = objValue.Elem()
	}
	if objType.Kind() != reflect.Struct {
		return nil, fmt.Errorf("obj must be a struct or a pointer to struct")
	}
	result := make(map[string]interface{})
	for i := 0; i < objType.NumField(); i++ {
		field := objType.Field(i)
		value := objValue.Field(i)
		tag := field.Tag.Get("json")
		if tag == "" || tag == "-" {
			continue
		}
		if field.Type.Kind() == reflect.Struct {
			nestedResult, err := StructSubToMapAny(value.Interface())
			if err != nil {
				return nil, err
			}
			result[tag] = nestedResult
		} else {
			result[tag] = value.Interface()
		}
	}
	return result, nil
}

// DeepCopy 函数用于深度拷贝任意类型的结构体，包括嵌套结构体
/*
type Address struct {
    City  string
    State string
}

type Person struct {
    Name    string
    Age     int
    Address Address
    Friends []string
}

func main() {
    original := &Person{
        Name:    "Alice",
        Age:     30,
        Address: Address{City: "Wonderland", State: "Fantasy"},
        Friends: []string{"Bob", "Charlie"},
    }

    // 进行深度拷贝
    copied, err := DeepCopy(original)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // 修改原始结构体中的数据
    original.Address.City = "New Wonderland"
    original.Friends[0] = "Dave"

    fmt.Println("Original:", original) // Original: &{Alice 30 {New Wonderland Fantasy} [Dave Charlie]}
    fmt.Println("Copied:", copied)     // Copied: &{Alice 30 {Wonderland Fantasy} [Bob Charlie]}
*/
func DeepCopy(src interface{}) (interface{}, error) {
	srcValue := reflect.ValueOf(src)

	// 确保 src 是指针类型
	if srcValue.Kind() != reflect.Ptr || srcValue.IsNil() {
		return nil, fmt.Errorf("source must be a non-nil pointer")
	}

	// 创建新的结构体
	dstValue := reflect.New(srcValue.Elem().Type()).Elem()

	// 遍历源结构体的字段
	for i := 0; i < srcValue.Elem().NumField(); i++ {
		field := srcValue.Elem().Field(i)

		switch field.Kind() {
		case reflect.Slice:
			// 处理切片字段
			newSlice := reflect.MakeSlice(field.Type(), field.Len(), field.Cap())
			for j := 0; j < field.Len(); j++ {
				elem := field.Index(j)
				if elem.Kind() == reflect.Map {
					// 处理 map 字段
					newMap := reflect.MakeMap(elem.Type())
					for _, key := range elem.MapKeys() {
						newValue := elem.MapIndex(key)
						// 进行深拷贝
						copiedValue, err := DeepCopy(newValue.Interface())
						if err != nil {
							return nil, err
						}
						newMap.SetMapIndex(key, reflect.ValueOf(copiedValue))
					}
					newSlice.Index(j).Set(newMap)
				} else {
					// 处理其他切片元素
					newSlice.Index(j).Set(elem)
				}
			}
			dstValue.Field(i).Set(newSlice)
		case reflect.Map:
			// 处理 map 字段
			newMap := reflect.MakeMap(field.Type())
			for _, key := range field.MapKeys() {
				newValue := field.MapIndex(key)
				// 进行深拷贝
				copiedValue, err := DeepCopy(newValue.Interface())
				if err != nil {
					return nil, err
				}
				newMap.SetMapIndex(key, reflect.ValueOf(copiedValue))
			}
			dstValue.Field(i).Set(newMap)
		case reflect.Struct:
			// 处理嵌套结构体
			newStruct, err := DeepCopy(field.Addr().Interface())
			if err != nil {
				return nil, err
			}
			dstValue.Field(i).Set(reflect.ValueOf(newStruct))
		default:
			// 处理其他字段
			dstValue.Field(i).Set(field)
		}
	}

	return dstValue.Interface(), nil
}

func ModeReturnFunc(mode string, modeFunc map[string]reflect.Value) reflect.Value {
	if funcName, ok := modeFunc[mode]; ok {
		if funcName.Kind() == reflect.Func {
			return funcName
		}
	}
	return reflect.Value{}
}

/*
StructSubJsonNameToMap ==> map

			  input ==>
			type Address struct {
				Street  string `json:"street"`
				City    string `json:"city"`
				Country string `json:"country"`
			}
			type Person struct {
				Name    string  `json:"name"`
				Age     int     `json:"age"`
				Gender  string  `json:"gender"`
				Address Address `json:"address"`
		}

		  person := Person{
				Name:   "Alice",
				Age:    30,
				Gender: "Female",
				Address: Address{
					Street:  "123 Main St",
					City:    "New York",
					Country: "USA",
				},
			}
			output ==>
			map[forceIndex: partition.ipg:[] partition.pg:[] sec.column:[] sec.lock: sec.unlock: whereAdd: whereSql:]
	}
*/
func StructSubJsonNameToMap(obj interface{}) (map[string]interface{}, error) {
	objType := reflect.TypeOf(obj)
	objValue := reflect.ValueOf(obj)
	if objType.Kind() == reflect.Ptr {
		objType = objType.Elem()
		objValue = objValue.Elem()
	}
	if objType.Kind() != reflect.Struct {
		return nil, fmt.Errorf("obj must be a struct or a pointer to struct")
	}
	result := make(map[string]interface{})
	for i := 0; i < objType.NumField(); i++ {
		field := objType.Field(i)
		value := objValue.Field(i)
		tag := field.Tag.Get("json")
		if tag == "" || tag == "-" {
			continue
		}
		if field.Type.Kind() == reflect.Struct {
			nestedResult, err := StructSubJsonNameToMap(value.Interface())
			if err != nil {
				return nil, err
			}
			for nestedKey, nestedValue := range nestedResult {
				result[tag+"."+nestedKey] = nestedValue
			}
		} else {
			result[tag] = value.Interface()
		}
	}
	return result, nil
}

/*
	c = TPod struct {
		Seq       int    `json:"seq"` //task打印的任务序号
		Schema    string `json:"schema"`
		Table     string `json:"table"`
		TableMiss bool
		CheckMode string `json:"mode"`
		Options   string `json:"options"`
		IndexName string `json:"indexName"`
		IndexType string `json:"indexType"`
		IndexCol  string `json:"indexCol"`
		Rows      Rows   `json:"rows"`
		Sync      Sync   `json:"sync"`
	}

createNewStruct(c, []string{seq,schema,table,mode,sync})
==>

	return struct{
		struct {
		    Seq       int    `json:"seq"` //task打印的任务序号
			Schema    string `json:"schema"`
			Table     string `json:"table"`
			CheckMode string `json:"mode"`
			Sync      Sync   `json:"sync"`
		}
	}
*/
func CreateNewStruct(original interface{}, fieldsToInclude []string) interface{} {
	origVal := reflect.ValueOf(original)
	origType := origVal.Type()

	// 创建一个新的结构体类型
	newFields := make([]reflect.StructField, 0)
	for _, fieldName := range fieldsToInclude {
		field, found := origType.FieldByName(fieldName)
		if found {
			newFields = append(newFields, field)
		}
	}

	// 定义新的结构体类型
	newStructType := reflect.StructOf(newFields)
	newStructValue := reflect.New(newStructType).Elem()

	// 设置字段值
	for _, fieldName := range fieldsToInclude {
		if fieldVal := origVal.FieldByName(fieldName); fieldVal.IsValid() {
			newStructValue.FieldByName(fieldName).Set(fieldVal)
		}
	}
	return newStructValue.Interface()
}

func GetJSONFieldNames(original interface{}) (columnFieldNames []string) {
	val := reflect.ValueOf(original)
	typ := val.Type()
	// 遍历结构体字段
	for i := 0; i < typ.NumField(); i++ {
		field := typ.Field(i)
		// 排除匿名字段和非导出字段
		if field.PkgPath == "" {
			jsonTag := field.Tag.Get("json")
			if jsonTag != "" && val.Field(i).Kind() != reflect.Struct {
				columnFieldNames = append(columnFieldNames, field.Name)
			}
		}
	}
	return
}

// StructNameJsonToSlice struct name json ===> slice
/*
	input ==>
	person := Person{
		Name:  "Alice" json:"name",
		Age:   25  json:"age",
		Email: "alice@example.com" json:"email",
	}
    output <==
	[]any{"name","age","email"}
*/
func StructNameJsonToSlice(s any) []any {
	var rowC []any
	objValue := reflect.ValueOf(s)
	if objValue.Kind() != reflect.Struct {
		//return nil, fmt.Errorf("传入的参数必须是结构体类型")
	}
	objType := objValue.Type()
	data := make(map[string]any)
	for i := 0; i < objValue.NumField(); i++ {
		field := objValue.Field(i)
		fieldType := objType.Field(i)
		fieldName := fieldType.Name

		jsonTag := fieldType.Tag.Get("json")
		if jsonTag != "" {
			fieldName = jsonTag
			rowC = append(rowC, fieldName)
			data[fieldName] = field.Interface()
		}

	}
	return rowC
}

// SplitSlice 大切片按照指定数据切割成多个小切片
func SplitSlice(slice []string, chunkSize int) [][]string {
	var result [][]string
	for i := 0; i < len(slice); i += chunkSize {
		end := i + chunkSize

		if end > len(slice) {
			end = len(slice)
		}
		result = append(result, slice[i:end])
	}
	return result
}

/*
DataSetFinalizer 手动回收字符串的内存数据
*/
func DataSetFinalizer(recoverData any) {
	switch fmt.Sprintf("%v", reflect.TypeOf(recoverData)) {
	case "string":
		stt := recoverData.(string)
		runtime.SetFinalizer(&stt, nil)
	case "*string":
		stt := recoverData.(*string)
		runtime.SetFinalizer(stt, nil)
	case "[]string":
		for _, v := range recoverData.([]string) {
			runtime.SetFinalizer(&v, nil)
		}
	case "[]*string":
		for _, v := range recoverData.([]*string) {
			runtime.SetFinalizer(v, nil)
		}
	case "[][]*string":
		for _, v := range recoverData.([][]*string) {
			for _, z := range v {
				runtime.SetFinalizer(z, nil)
			}
		}
	case "[][]string":
		for _, v := range recoverData.([][]string) {
			for _, z := range v {
				runtime.SetFinalizer(&z, nil)
			}
		}
	}
}

/*
		StructValueToSlice struct value ===> slice
		input ==>
		person := Person{
			Name:  "Alice",
			Age:   25,
			Email: "alice@example.com",
		}
	    output <==
		[]any{alice,25,"alice@example.com"}
*/
func StructValueToSlice(s interface{}) []string {
	// 通过反射获取结构体的值
	value := reflect.ValueOf(s)
	if value.Kind() != reflect.Struct {
		fmt.Println("Expected a struct")
		return nil
	}

	// 获取结构体字段的数量
	numFields := value.NumField()

	// 创建一个切片用于存储结构体字段的值
	slice := make([]string, numFields)

	// 遍历结构体字段
	for i := 0; i < numFields; i++ {
		// 获取字段的值
		fieldValue := value.Field(i).Interface()
		// 将字段值存储到切片中
		slice[i] = fmt.Sprintf("%v", fieldValue)
	}
	return slice
}

// StructPointerValueToSlice struct value ===> slice
/*
	input ==>
	sf := 25
	person := Person{
		Name:  "Alice",
		Age:   &sf,
		Email: "alice@example.com",
	}
    output <==
	[]any{alice,25,"alice@example.com"}
*/
func StructPointerValueToSlice(s interface{}) []string {
	// 通过反射获取结构体的值
	value := reflect.ValueOf(s)
	if value.Kind() != reflect.Struct {
		fmt.Println("Expected a struct")
		return nil
	}
	// 获取结构体字段的数量
	numFields := value.NumField()
	// 创建一个切片用于存储结构体字段的值
	slice := make([]string, numFields)
	// 遍历结构体字段
	for i := 0; i < numFields; i++ {
		filed := value.Field(i)
		//判断结构体中是否包含指针,则获取指针指向实际的值
		if filed.Kind() == reflect.Ptr && !filed.IsNil() {
			filed = filed.Elem()
		}
		// 获取字段的值
		fieldValue := filed.Interface()
		// 将字段值存储到切片中
		slice[i] = fmt.Sprintf("%v", fieldValue)
	}
	return slice
}

// StructJsonPointerValueToSlice struct value ===> slice
/*
	input ==>
	sf := 25
	person := Person{
		Name:  "Alice"  json "name",
		Age:   &sf json "age",
		Email: "alice@example.com",
	}
    output <==
	[]any{alice,25}
*/
func StructJsonPointerValueToSlice(s interface{}) []string {
	// 通过反射获取结构体的值
	value := reflect.ValueOf(s)
	objType := value.Type()
	if value.Kind() != reflect.Struct {
		fmt.Println("Expected a struct")
		return nil
	}
	// 获取结构体字段的数量
	numFields := value.NumField()
	// 创建一个切片用于存储结构体字段的值
	var slice []string
	// 遍历结构体字段
	for i := 0; i < numFields; i++ {
		typeValue := objType.Field(i)
		filed := value.Field(i)
		//判断结构体中是否包含指针,则获取指针指向实际的值
		if filed.Kind() == reflect.Ptr && !filed.IsNil() {
			filed = filed.Elem()
		}
		// 获取字段的值
		fieldValue := filed.Interface()
		// 将字段值存储到切片中
		jsonTag := typeValue.Tag.Get("json")
		if jsonTag != "" && jsonTag != "-" {
			slice = append(slice, fmt.Sprintf("%v", fieldValue))
		}
	}
	return slice
}

/*
	 定义结构体
type Person struct {
    Name *string `json:"name"`
    Age  *int    `json:"age"`
}
    name := "Alice"
    age := 30
    data := map[string]any{
        "name": &name,
        "age":  &age,
    }

    // 创建结构体实例
    person := &Person{}
	err := mapToStruct(data, person)
*/
// MapToStructJson 将map[string]interface{}转换为指定的结构体类型并赋值
func MapToStructJson(data map[string]interface{}, obj interface{}) error {
	objValue := reflect.ValueOf(obj)
	if objValue.Kind() != reflect.Ptr || objValue.IsNil() {
		return fmt.Errorf(`invalid object, must be a non-nil pointer to a struct`)
	}
	objValue = objValue.Elem()
	if objValue.Kind() != reflect.Struct {
		return fmt.Errorf(`invalid object, must be a pointer to a struct`)
	}
	objType := objValue.Type()
	for i := 0; i < objType.NumField(); i++ {
		field := objType.Field(i)
		fieldValue := objValue.Field(i)

		if !fieldValue.CanSet() {
			continue
		}

		fieldName := field.Name
		if tag := field.Tag.Get("json"); tag != "" {
			fieldName = tag
		}

		value, ok := data[fieldName]
		if !ok {
			continue
		}

		fieldType := fieldValue.Type()
		valueType := reflect.TypeOf(value)
		if !valueType.AssignableTo(fieldType) {
			return fmt.Errorf(fmt.Sprintf("Incompatible value for field %s", fieldName))
		}

		fieldValue.Set(reflect.ValueOf(value))
	}

	return nil
}

// MapStructValues 映射结构体值的递归函数
func MapStructValues(sourceValue reflect.Value, destinationValue reflect.Value) {
	// 检查源值和目标值的类型是否相同
	//if sourceValue.Type() != destinationValue.Type() {
	//	return
	//}
	// 解引用指针类型的值
	if sourceValue.Kind() == reflect.Ptr {
		sourceValue = sourceValue.Elem()
	}
	if destinationValue.Kind() == reflect.Ptr {
		destinationValue = destinationValue.Elem()
	}
	sinceStructSeq := 0
	// 处理结构体字段
	for i := 0; i < sourceValue.NumField(); i++ {
		sourceField := sourceValue.Type().Field(i)
		sourceFieldValue := sourceValue.Field(i)
		// 检查字段是否带有json标签
		if jsonTag := sourceField.Tag.Get("json"); jsonTag != "" {
			sinceStructSeq++
			destinationField := destinationValue.FieldByName(sourceField.Name)
			// 检查目标结构体是否存在字段
			if destinationField.IsValid() && destinationField.CanSet() {
				// 检查字段类型
				if destinationField.Type() == sourceFieldValue.Type() {
					// 设置字段值
					destinationField.Set(sourceFieldValue)
				} else {
					// 如果字段类型不匹配，尝试使用JSON进行转换
					destinationJSON, _ := json.Marshal(sourceFieldValue.Interface())
					_ = json.Unmarshal(destinationJSON, destinationField.Addr().Interface())
				}
			}
			// 如果是结构体类型，则递归处理子结构体
			if sourceFieldValue.Kind() == reflect.Struct {
				MapStructValues(sourceFieldValue, destinationValue.Field(sinceStructSeq-1))
			}
			//// 如果是指针类型，则创建新的目标指针并递归处理
			//if sourceFieldValue.Kind() == reflect.Ptr && destinationField.Kind() == reflect.Ptr {
			//	if !sourceFieldValue.IsNil() {
			//		newDestinationValue := reflect.New(destinationField.Type().Elem())
			//		mapStructValues(sourceFieldValue.Elem(), newDestinationValue.Elem())
			//		destinationField.Set(newDestinationValue)
			//	}
			//}
		}
	}
}

func MapSubToStructSubJsonName(m map[string]any, dest interface{}) error {
	destValue := reflect.ValueOf(dest).Elem()
	for i := 0; i < destValue.NumField(); i++ {
		field := destValue.Field(i)
		fieldType := field.Type()
		fieldName := destValue.Type().Field(i).Name
		jsonTag := destValue.Type().Field(i).Tag.Get("json")
		value, ok := m[jsonTag]
		if !ok {
			continue
		}
		switch fieldType.Kind() {
		case reflect.String:
			field.SetString(fmt.Sprintf("%v", value))
		case reflect.Bool:
			field.SetBool(value.(bool))
		case reflect.Int64:
			field.SetInt(value.(int64))
		case reflect.Slice:
			switch fmt.Sprintf("%v", reflect.TypeOf(value)) {
			case "[]string":
				newSkillsValue := reflect.ValueOf(value.([]string))
				field.Set(newSkillsValue)
				//case "[]int":
			}
		case reflect.Struct:
			var subMap = make(map[string]any)
			subMap = value.(map[string]any)
			subStruct := reflect.New(fieldType).Elem()
			err := MapSubToStructSubJsonName(subMap, subStruct.Addr().Interface())
			if err != nil {
				return err
			}
			field.Set(subStruct)
		default:
			return fmt.Errorf("unsupported field type %s for field %s", fieldType.Kind(), fieldName)
		}
	}
	return nil
}

/*
	HasNonStructZeroValue

判断结构体是否为空值
type Person struct {
Name string
Age  int
}

	p1 := Person{Name: "Alice", Age: 25}   --->true
	p2 := Person{}  --->false
*/
func HasNonStructZeroValue(obj interface{}) bool {
	// 检查结构体是否为nil
	if obj == nil {
		return true
	}

	// 使用反射检查结构体的字段是否都是零值
	value := reflect.ValueOf(obj)
	for i := 0; i < value.NumField(); i++ {
		field := value.Field(i)
		if !field.IsZero() {
			return false
		}
	}

	return true
}

// AnySliceToString 接口类型切片转换为字符串
func AnySliceToString(f []any) string {
	var a []string
	for _, v := range f {
		a = append(a, fmt.Sprintf("%v", v))
	}
	return strings.Join(a, StructColumnSplit)
}

// AnySliceToStringSlice 接口类型切片转换为切片字符串
func AnySliceToStringSlice(f []any) []string {
	var a []string
	for _, v := range f {
		a = append(a, fmt.Sprintf("%v", v))
	}
	return a
}

// HandlePanic 捕获 panic 的函数
func HandlePanic() (p string) {
	if r := recover(); r != nil {
		p = fmt.Sprintf("Recovered from panic: %v", r)
	}
	return
}

func IfFileOrDir(path string) (string, error) {
	// 获取文件或目录的信息
	fileInfo, err := os.Stat(path)
	if err != nil {
		if !os.IsNotExist(err) {
			fmt.Println("无法获取文件或目录信息:", err)
			return "", err
		} else {
			return "dir", nil
		}
	}
	// 判断是否为目录
	if fileInfo.IsDir() {
		return "dir", nil
	} else {
		return "file", nil
	}
}

// FilePathIsNotExist 判断指定的文件路径是否存在，不存在则创建
func FilePathIsNotExist(path string) bool {
	// 检查目录是否存在
	if _, err := os.Stat(path); os.IsNotExist(err) {
		// 目录不存在，创建目录
		err = os.MkdirAll(path, 0755)
		if err != nil {
			fmt.Println("无法创建目录:", err)
			return false
		}
	}
	return true
}

// FilePathExistDelete 判断指定的文件路径是否存在，存在则删除
func FilePathExistDelete(path string) bool {
	// 检查目录是否存在
	if _, err := os.Stat(path); err == nil {
		// 目录存在，删除它
		err = os.RemoveAll(path)
		if err != nil {
			fmt.Printf("删除目录失败：%v\n", err)
			return false
		}
	} else if os.IsNotExist(err) {
		// 目录不存在
		//fmt.Printf("目录不存在：%s\n", path)
	} else {
		// 其他错误
		fmt.Printf("无法访问目录：%v\n", err)
	}
	return true
}

// FileExists 文件是否存在的函数
func FileExists(filename string) bool {
	if _, err := os.Stat(filename); os.IsNotExist(err) {
		return false // 文件不存在
	}
	return true // 文件存在
}

// FileIsNotExist 判断指定的文件是否存在，不存在则创建,如果指定的绝对路径，但绝对路径不存在，则进行递归创建
func FileIsNotExist(path string) (*os.File, error) {
	var (
		file *os.File
		err  error
	)
	// 获取文件的上层目录
	dirPath := filepath.Dir(path)
	if FilePathIsNotExist(dirPath) {
		file, err = os.Create(path)
		if err != nil {
			fmt.Println("无法创建文件:", err)
			return nil, err
		}
	}
	return file, nil
}

// SubPathDirName 输出指定的路径下子目录名称,并只返回子目录名称
func SubPathDirName(inputPath string) ([]string, error) {
	subDirs := make([]string, 0)
	err := filepath.WalkDir(inputPath, func(path string, d os.DirEntry, err error) error {
		if err != nil {
			fmt.Printf("遍历目录时遇到错误: %v\n", err)
			return err
		}
		if !d.IsDir() && path != inputPath {
			subDirs = append(subDirs, d.Name())
		}
		return nil
	})
	if err != nil {
		fmt.Printf("遍历目录时遇到错误: %v\n", err)
		return nil, err
	}
	return subDirs, nil
}

// SubFileIsNotExist 判断指定的子文件是否存在
func SubFileIsNotExist(subFile string) (*os.File, error) {
	var (
		file *os.File
		err  error
	)
	if _, err = os.Stat(subFile); os.IsNotExist(err) {
		return nil, err
	} else if err == nil {
		file, err = os.Open(subFile)
		if err != nil {
			fmt.Printf("无法打开文件 %s: %v\n", subFile, err)
			return nil, err
		}
	} else {
		fmt.Printf("判断文件是否存在时遇到错误: %v\n", err)
		return nil, err
	}
	return file, nil
}

// FileIsExtRemove 判断文件是否为空，为空则删除
func FileIsExtRemove(file string) (bool, error) {
	var (
		fileF    *os.File
		err      error
		fileInfo os.FileInfo
	)
	fileType := reflect.TypeOf(file)
	if strings.EqualFold(fileType.String(), "string") {
		// 打开文件
		if fileF, err = os.Open(reflect.ValueOf(file).String()); err != nil {
			return false, err
		}
	} else if strings.EqualFold(fileType.String(), "*os.File") {
		fileF = reflect.ValueOf(file).Interface().(*os.File)
	}
	if fileF == nil {
		return false, nil
	}
	// 获取文件信息
	if fileInfo, err = fileF.Stat(); err != nil {
		return false, err
	}
	// 判断文件大小是否为 0
	if fileInfo.Size() == 0 {
		if err = fileF.Close(); err != nil {
			return false, err
		}
		// 删除空文件
		if err = os.Remove(file); err != nil {
			return false, err
		}
	}
	return true, nil
}
func CheckAndDeleteDir(dirPath string) error {
	isEmpty, err := IsDirEmpty(dirPath)
	if err != nil {
		return err
	}

	if isEmpty {
		return os.RemoveAll(dirPath)
	}
	return nil
}

func IsDirEmpty(dirPath string) (bool, error) {
	entries, err := os.ReadDir(dirPath)
	if err != nil {
		return false, err
	}
	return len(entries) == 0, nil
}

// JoinPath 拼接路径的函数
func JoinPath(bashPath, relativePath string) (string, error) {
	var (
		currentDir string
		err        error
	)
	if len(bashPath) == 0 {
		// 获取当前工作目录
		if currentDir, err = os.Getwd(); err != nil {
			return "", err
		}
	} else {
		currentDir = bashPath
	}
	// 根据操作系统类型选择分隔符
	var separator string
	sysType := runtime.GOOS
	switch sysType {
	case "linux":
		separator = "/"
	case "windows":
		separator = "\\"
	}
	// 拼接路径
	fullPath := currentDir + separator + relativePath
	return fullPath, nil
}


func EnsurePathExists(fullPath string) (bool, error) {
	if _, err := os.Stat(fullPath); os.IsNotExist(err) {
		// 如果路径不存在，则创建
		err = os.MkdirAll(fullPath, os.ModePerm)
		if err != nil {
			return false, err
		}
	} else if err != nil {
		return false, err
	}
	return true, nil
}
func AnyToJsonString(s any) string {
	if q, err := json.Marshal(s); err != nil {
		return ""
	} else {
		return string(q)
	}
}

// Second 计算两个时间戳的插值，返回一个s为单位的字符串，保留两位小数
func Second(t1, t2 int64) string {
	// 计算时间戳差值
	diff := t2 - t1
	// 将纳秒差值转换为秒数
	seconds := float64(diff) / float64(time.Second)
	return fmt.Sprintf("%.2f", seconds)
}

// Percent 计算两个数的百分比，返回一个字符串，保留两位小数
func Percent(current, total int64) string {
	if total == 0 {
		return fmt.Sprintf("%v%%", "0.00")
	}
	percent := float64(current) / float64(total) * 100
	return fmt.Sprintf("%.2f%%", percent)
}

// PercentFloat 计算两个数的百分比，返回一个字符串，保留两位小数
func PercentFloat(current, total int64) float64 {
	if total == 0 {
		return 0
	}
	percent := float64(current) / float64(total) * 100
	return math.Round(percent*100) / 100
}

/*
IsChineseOrRare
false：不包含中文或生僻字。
true：包含中文或生僻字
*/
func IsChineseOrRare(s string) bool {
	// 正则表达式匹配非 ASCII 字符
	re := regexp.MustCompile(`[^\x00-\x7F]`)
	// 返回是否匹配
	return re.MatchString(s)
}

// CompareFloats 比较两个float的大小，大于返回true
func CompareFloats(a, b float64) bool {
	if a > b {
		return true
	} else {
		return false
	}
}

// Commercial 计算两个数的百分比，返回一个字符串，保留两位小数
func Commercial(current, total int64) string {
	if total == 0 {
		return fmt.Sprintf("%v%%", "0.00")
	}
	percent := float64(current) / float64(total)
	return fmt.Sprintf("%.2f", percent)
}

// CompareSlices compares two slices of integers and returns a slice of integers
// with 1 for elements in the first slice greater than the second,
// -1 for elements less than, and 0 for elements equal.
func CompareSlices(slice1, slice2 []int) []int {
	length := len(slice1)
	if len(slice2) < length {
		length = len(slice2) // Compare only up to the length of the shorter slice
	}

	result := make([]int, length)

	for i := 0; i < length; i++ {
		if slice1[i] > slice2[i] {
			result[i] = 1
		} else if slice1[i] < slice2[i] {
			result[i] = -1
		} else {
			result[i] = 0
		}
	}

	return result
}
